var myFn = {};

/**
 * 计算 A 除以 B 的百分比，并格式化为不带小数的整数百分比字符串。
 * @param {number} dividend 被除数 (A)
 * @param {number} divisor 除数 (B)
 * @returns {string} 格式化后的百分比字符串，例如 "25%"
 */
myFn.calculateIntegerPercentage = (dividend, divisor) => {
  // 关键步骤1：处理除数为0或无效的情况
  if (!divisor) {
    return "0%";
  }

  // 关键步骤2：进行除法运算
  const result = dividend / divisor;

  // 关键步骤3：使用 Math.round() 四舍五入到最近的整数
  const roundedResult = result.toFixed(2);

  // 关键步骤4：将整数转换为字符串并加上 "%"
  return `${roundedResult}%`;
}

/**
 * 手动格式化数字
 * @param {number} num 要格式化的数字
 * @returns {string} 格式化后的字符串
 */
myFn.formatNumberManually = (num) => {
  if (typeof num !== 'number' || isNaN(num)) {
    return '0.00';
  }

  // 1. 保留两位小数，并转为字符串
  let numStr = num.toFixed(2);

  // 2. 分割整数和小数部分
  let parts = numStr.split('.');
  let integerPart = parts[0];
  let decimalPart = parts[1];

  // 3. 使用正则表达式为整数部分添加逗号
  // \B 匹配非单词边界
  // (?=(\d{3})+(?!\d)) 是一个正向先行断言，确保后面有3的倍数个数字，并且这串数字的结尾不是数字
  let regex = /\B(?=(\d{3})+(?!\d))/g;
  integerPart = integerPart.replace(regex, ',');

  // 4. 重新组合
  return integerPart + '.' + decimalPart;
}

/**
 * 错误提示框
 * @param {string} message - 错误信息
 */
myFn.showErrorToast = (message) => {
  wx.showToast({
    title: message,
    icon: 'none',
    duration: 1000,
  });
};

/**
 * 错误提示框
 * @param {string} message - 错误信息
 */
myFn.showToast = (message, icon) => {
  wx.showToast({
    title: message,
    icon: icon || 'none',
    duration: 1000,
  });
};

/**
 * 判断传入的日期是否为今天
 * @param {string} dateStr - 日期字符串，格式为YYYY-MM-DD
 * @returns {boolean} 如果是今天返回true，否则返回false
 */
myFn.isToday = function (dateStr, days) {
  // 验证日期格式
  if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
    console.error('日期格式错误，请使用YYYY-MM-DD格式');
    return false;
  }

  // 解析传入的日期
  const inputDate = new Date(dateStr);

  // 验证日期是否有效
  if (isNaN(inputDate.getTime())) {
    console.error('无效的日期');
    return false;
  }

  // 获取今天的日期
  const today = new Date();

  // 比较年、月、日
  return days >= 7 ? true : inputDate.getFullYear() === today.getFullYear() &&
    inputDate.getMonth() === today.getMonth() &&
    inputDate.getDate() === today.getDate();
}
/**
 * 从对象数组中提取数值属性
 * @param {Array} dataArray - 对象数组
 * @param {string} valueProperty - 数值属性名
 * @returns {Array} 数值数组
 */
myFn.extractValues = function (dataArray, valueProperty = 'value') {
  return dataArray.map(item => {
    const value = item[valueProperty];
    if (typeof value !== 'number') {
      throw new Error(`属性"${valueProperty}"不是数值类型`);
    }
    return value;
  });
}

/**
 * 计算数据标准化参数
 * @param {Array} values - 数值数组
 * @param {number} maxHeight - 最大高度（150px）
 * @param {number} padding - 内边距
 * @returns {Object} 标准化参数
 */
myFn.calculateNormalizationParams = function (values, maxHeight = 150, padding = 2) {
  const min = Math.min(...values);
  const max = Math.max(...values);
  const range = max - min;

  // 处理所有值相同的情况
  if (range === 0) {
    return {
      min,
      max,
      range,
      scaleFactor: (maxHeight - padding * 2) / 100 // 默认给100的范围
    };
  }

  const availableHeight = maxHeight - padding * 2;
  const scaleFactor = availableHeight / range;

  return { min, max, range, scaleFactor, availableHeight };
}

/**
 * 标准化对象数组数据
 * @param {Array} dataArray - 原始对象数组
 * @param {string} valueProperty - 数值属性名
 * @param {number} maxHeight - 最大高度
 * @param {number} padding - 内边距
 * @returns {Array} 标准化后的对象数组
 */
myFn.normalizeObjectArray = function (dataArray, valueProperty = 'value', maxHeight = 150, padding = 2) {
  const values = this.extractValues(dataArray, valueProperty);
  const params = this.calculateNormalizationParams(values, maxHeight, padding);

  return dataArray.map((item, index) => {
    const originalValue = item[valueProperty];
    const normalizedHeight = (originalValue - params.min) * params.scaleFactor;
    const canvasY = maxHeight - normalizedHeight - padding;

    return {
      ...item,
      originalValue,
      normalizedHeight,
      canvasY,
      barHeight: normalizedHeight
    };
  });
}

export default myFn;